The present invention relates to data storage systems, and more specifically, this invention relates to leveraging temporal locality between files in order to avoid accessing a central inode list.
The continued increase of resilience for filesystems is an issue which is addressed on ongoing basis. Most filesystems initially start as a superblock which is located at an arbitrary address in a logical unit number (LUN), volume, logical disk, etc. From the superblock, a structure is built which ultimately becomes the filesystem. Files (e.g., unique groupings of data) stored on the filesystem are typically separated into a number of blocks which are spread across the persistent storage space of memory in order to achieve even distribution, e.g., for performance reasons. Thus, in order to describe each of these blocks and keep track of where they are located in the persistent storage space, a structure called a central inode list is used. This inode list identifies where the logical block addresses (LBAs) that constitute the various portions (e.g., blocks) of a given file are located in the memory space, and how these correlate to the corresponding locations in the persistent storage space. Accordingly, each file has an inode which is stored in one or more arrays depending on the architecture.
However, as file systems grow and become larger, multiple processes and/or threads are allowed to simultaneously access a single inode list. Accordingly, the inode list can become a performance bottleneck and consume valuable system resources, including but not limited to memory and central processing units (CPUs). Moreover, lease and lock requests are implemented per inode in order to access files which adds another layer of complexity to the process of accessing data stored in memory.